1
2
De volgende
In de eenvoudigste bewoordingen doet git pull een git fetch gevolgd door een git merge.
Je kunt op elk moment een git fetch doen om je remote-tracking branches bij te werken onder refs / remotes / /.
Deze operatie verandert nooit je eigen lokale branches onder refs / heads, en is veilig om te doen zonder je werkkopie te veranderen. Ik heb zelfs gehoord dat mensen git fetch periodiek uitvoeren in een cron-taak op de achtergrond (hoewel ik dit niet zou aanraden).
Een git pull is wat je zou doen om een lokale branch up-to-date te brengen met zijn remote versie, terwijl je ook je andere remote tracking branches bijwerkt.
Van de Git-documentatie voor git pull:
In de standaardmodus is git pull een afkorting voor git fetch gevolgd door git merge FETCH_HEAD.
|
Als je pull gebruikt, probeert Git automatisch je werk voor je te doen. Het is contextgevoelig, dus Git zal alle getrokken commits mergen in de branch waarin je momenteel aan het werken bent. Pull voegt automatisch de commits samen zonder dat je ze eerst moet bekijken. Als u uw filialen niet nauw beheert, kunt u regelmatig conflicten tegenkomen.
Wanneer je fetch verzamelt, verzamelt Git alle commits van de doelbranch die niet in je huidige branch bestaat en slaat ze op in je lokale repository. Het voegt ze echter niet samen met uw huidige branch. Dit is vooral handig als u uw repository up-to-date wilt houden, maar aan iets werkt dat mogelijk kapot gaat als u uw bestanden bijwerkt.
Om de commits in je master branch te integreren, gebruik je merge.
|
Het is belangrijk om de ontwerpfilosofie van git te contrasteren met de filosofie van een meer traditionele source control-tool zoals SVN.
Subversion is ontworpen en gebouwd met een client / server-model. Er is een enkele repository die de server is, en verschillende clients kunnen code van de server halen, eraan werken en deze vervolgens weer vastleggen op de server. De aanname is dat de client altijd contact kan opnemen met de server wanneer deze een bewerking moet uitvoeren.
Git is ontworpen om een meer gedistribueerd model te ondersteunen zonder dat er een centrale repository nodig is (hoewel je er zeker een kunt gebruiken als je wilt). Ook is git zo ontworpen dat de client en de "server" niet tegelijkertijd online hoeven te zijn. Git is zo ontworpen dat mensen op een onbetrouwbare link zelfs code via e-mail kunnen uitwisselen. Het is mogelijk om volledig losgekoppeld te werken en een CD te branden om code uit te wisselen via git.
Om dit model te ondersteunen onderhoudt git een lokale repository met jouw code en ook een extra lokale repository die de staat van de remote repository weerspiegelt. Door een kopie van de remote repository lokaal te bewaren, kan git de benodigde wijzigingen achterhalen, zelfs als de remote repository niet bereikbaar is. Als je de wijzigingen later naar iemand anders moet sturen, kan git ze als een set wijzigingen overdragen vanaf een tijdstip dat bekend is bij de externe repository.
git fetch is het commando dat zegt "breng mijn lokale kopie van de remote repository up-to-date."
git pull zegt "breng de veranderingen in de remote repository naar waar ik mijn eigen code bewaar."
Normaal gesproken doet git pull dit door een git fetch uit te voeren om de lokale kopie van de remote repository up-to-date te brengen, en vervolgens de wijzigingen in je eigen code repository en mogelijk je werkkopie samen te voegen.
Het meenemen is om in gedachten te houden dat er vaak minstens drie exemplaren van een project op uw werkstation staan. Een exemplaar is je eigen repository met je eigen vastleggeschiedenis. De tweede kopie is je werkkopie waar je aan het bewerken en bouwen bent. De derde kopie is uw lokale kopie van een externe opslagplaats.
|
Hier is Oliver Steele's beeld van hoe alles in elkaar past:
Als er voldoende interesse is, denk ik dat ik de afbeelding zou kunnen bijwerken om git clone en git merge toe te voegen ...
|
Een gebruiksscenario van git fetch is dat het volgende je alle veranderingen in de remote branch zal vertellen sinds je laatste pull ... dus je kunt dit controleren voordat je een daadwerkelijke pull doet, wat bestanden in je huidige branch en werkkopie zou kunnen veranderen.
git fetch
git diff ... oorsprong
Zie: https://git-scm.com/docs/git-diff met betrekking tot syntaxis met dubbele en driedubbele puntjes in het diff-commando
|
Het kostte me een beetje om te begrijpen wat het verschil was, maar dit is een eenvoudige verklaring. master in uw localhost is een branch.
Als je een repository kloont, haal je de hele repository op naar je lokale host. Dit betekent dat je op dat moment een oorsprong / master pointer hebt naar HEAD en master die naar dezelfde HEAD wijst.
wanneer je begint te werken en commits doet, zet je de master pointer op HEAD + je commits. Maar de origin / master-pointer wijst nog steeds naar wat het was toen je kloneerde.
Het verschil zal dus zijn:
Als je een git fetch doet, zal het alle wijzigingen in de remote repository (GitHub) ophalen en de origin / master pointer naar HEAD verplaatsen. Ondertussen zal je lokale branch master blijven wijzen naar waar het is.
Als je een git pull doet, zal het in feite fetch doen (zoals eerder uitgelegd) en eventuele nieuwe wijzigingen in jemaster branch en verplaats de aanwijzer naar HEAD.
|
Soms helpt een visuele weergave.
|
Kort
git fetch is vergelijkbaar met pull, maar wordt niet samengevoegd. d.w.z. het haalt externe updates op (refs en objecten) maar uw lokale blijft hetzelfde (d.w.z. origin / master wordt bijgewerkt maar master blijft hetzelfde).
git pull trekt naar beneden vanaf een afstandsbediening en fuseert onmiddellijk.
Meer
git clone klonen een repo.
git rebase bewaart dingen van je huidige branch die zich niet in de upstream branch bevindt naar een tijdelijk gebied. Uw branch is nu hetzelfde als voordat u met uw wijzigingen begon. Dus git pull -rebase zal de externe wijzigingen ophalen, je lokale branch terugspoelen, je wijzigingen een voor een over je huidige branch herhalen totdat je up-to-date bent.
Ook zal git branch -a je precies laten zien wat er aan de hand is met al je branches - lokaal en op afstand.
Deze blogpost was nuttig:
Het verschil tussen git pull, git fetch en git clone (en git rebase) - Mike Pearce
en omvat git pull, git fetch, git clone en git rebase.
====
BIJWERKEN
Ik dacht dat ik dit zou updaten om te laten zien hoe je dit in de praktijk zou gebruiken.
Werk uw lokale repo bij vanaf de afstandsbediening (maar voeg niet samen):
git fetch
Laten we na het downloaden van de updates de verschillen bekijken:
git diff master oorsprong / master
Als u tevreden bent met die updates, voegt u samen:
git pull
Opmerkingen:
Over stap 2: Voor meer informatie over verschillen tussen lokale en remotes, zie: Hoe vergelijk je een lokale git branch met zijn remote branch?
Bij stap 3: het is waarschijnlijk nauwkeuriger (bijv. Bij een snel veranderende opslagplaats) om hier een git rebase-oorsprong uit te voeren. Zie @ Justin Ohms commentaar in een ander antwoord.
Zie ook: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Fetchen van en samenvoegen met een andere repository of een lokale branch
KORTE INHOUD
git pull ...
OMSCHRIJVING
Voert git-fetch uit met de gegeven parameters, en roept git-merge aan om het
opgehaalde kop (pen) in de huidige tak. Met --rebase, roept git-rebase aan
in plaats van git-merge.
Merk op dat u. (huidige directory) als de die moet worden opgehaald
vanuit de lokale repository - dit is handig bij het samenvoegen van lokale branches
in de huidige branch.
Merk ook op dat opties bedoeld zijn voor git-pull zelf en onderliggende git-merge
moet worden gegeven vóór de opties bedoeld voor git-fetch.
Je zou trekken als je de geschiedenissen wilt samenvoegen, je zou halen als je gewoon 'de codez wilt', aangezien iemand hier een aantal artikelen heeft getagd.
|
U kunt ophalen uit een externe repository, de verschillen zien en vervolgens ophalen of samenvoegen.
Dit is een voorbeeld voor een remote repository genaamd origin en een branch genaamd master die de remote branch origin / master volgt:
git checkout master
git fetch
git diff oorsprong / master
git rebase oorsprong master
|
Het korte en gemakkelijke antwoord is dat git pull simpelweg git fetch is, gevolgd door git merge.
Het is erg belangrijk op te merken dat git pull automatisch zal mergen, of je het nu leuk vindt of niet. Dit kan natuurlijk leiden tot samenvoegingsconflicten. Laten we zeggen dat je remote origin is en je branch master. Als je diff origin / master git voordat je gaat trekken, zou je een idee moeten hebben van mogelijke samenvoegconflicten en je lokale branch dienovereenkomstig kunnen voorbereiden.
Naast het trekken en duwen, omvatten sommige workflows git rebase, zoals deze, die ik parafraseer uit het gelinkte artikel:
git pull oorsprong master
git checkout foo-branch
git rebase master
git push oorsprong foo-branch
Als je jezelf in een dergelijke situatie bevindt, kom je misschien in de verleiding om git pull --rebase te gebruiken. Tenzij u echt, echt weet wat u doet, zou ik dat afraden. Deze waarschuwing is van de man-pagina voor git-pull, versie 2.3.5:
Dit is een potentieel gevaarlijke manier van werken. Het herschrijft
geschiedenis, wat niet veel goeds voorspelt toen u die geschiedenis publiceerde
nu al. Gebruik deze optie niet tenzij je git-rebase (1) hebt gelezen
voorzichtig.
|
OK, hier is wat informatie over git pull en git fetch, zodat je de feitelijke verschillen kunt begrijpen ... in een paar simpele woorden haalt fetch de laatste data op, maar niet de code verandert en gaat niet rommelen met je huidige lokale branch-code , maar haal de codewijzigingen op en voeg het samen met je lokale branch, lees verder voor meer details over elk:
git fetch
Het zal alle referenties en objecten en eventuele nieuwe branches downloaden naar uw lokale repository ...
Haal branches en / of tags (gezamenlijk "refs") op van een of meer
andere repositories, samen met de objecten die nodig zijn om hun
geschiedenissen. Remote-tracking branches worden bijgewerkt (zie de beschrijving
hieronder voor manieren om dit gedrag te beheersen).
Standaard is elke tag die verwijst naar de geschiedenissen die worden opgehaald
ook opgehaald; het effect is om tags op te halen die verwijzen naar takken die
waarin u geïnteresseerd bent. Dit standaardgedrag kan worden gewijzigd met
de --tags of --no-tags opties of door
afstandsbediening..tagOpt. Door een refspec te gebruiken die tags expliciet ophaalt,
u kunt tags ophalen die niet verwijzen naar branches waarin u geïnteresseerd bent
ook in.
git fetch kan ophalen vanofwel een enkele benoemde repository of URL, of
van verschillende repositories tegelijk als wordt gegeven en er is een
afstandsbedieningen. vermelding in het configuratiebestand. (Zie git-config1).
Als er geen afstandsbediening is opgegeven, is de oorspronkelijke afstandsbediening standaard
gebruikt, tenzij er een stroomopwaartse tak is geconfigureerd voor de stroom
Afdeling.
De namen van refs die worden opgehaald, samen met de objectnamen
ze verwijzen naar, zijn geschreven naar .git / FETCH_HEAD. Deze informatie kan zijn
gebruikt door scripts of andere git-commando's, zoals git-pull.
git pull
Het zal de wijzigingen van remote naar de huidige branch in local ...
Verwerkt wijzigingen van een externe repository naar de huidige branch.
In de standaardmodus is git pull een afkorting voor git fetch gevolgd door
git merge FETCH_HEAD.
Preciezer gezegd, git pull voert git fetch uit met de gegeven parameters en
roept git merge aan om de opgehaalde branch heads samen te voegen met de huidige
Afdeling. Met --rebase wordt git rebase uitgevoerd in plaats van git merge.
zou de naam moeten zijn van een externe repository zoals doorgegeven aan
git-fetch1. kan een willekeurige remote ref een naam geven (bijvoorbeeld
de naam van een tag) of zelfs een verzameling refs met bijbehorende
remote-tracking branches (bijv. refs / heads /: refs / remotes / origin /),
maar meestal is het de naam van een branch in de remote repository.
Standaardwaarden voor en worden gelezen uit de
"remote" en "merge" configuratie voor de huidige branch zoals ingesteld door
git-branch --track.
Ik maak ook de onderstaande visual om je te laten zien hoe git fetch en git pull samenwerken ...
|
Deze interactieve grafische weergave is erg handig bij het onderschatten van git: http://ndpsoftware.com/git-cheatsheet.html
git fetch "downloadt" gewoon de wijzigingen van de afstandsbediening naar uw lokale repository. git pull downloadt de wijzigingen en voegt ze samen in je huidige branch. "In de standaardmodus is git pull een afkorting voor git fetch gevolgd door git merge FETCH_HEAD."
|
Bonus:
Als ik het heb over pull & fetch in de bovenstaande antwoorden, wil ik een interessante truc delen,
git pull --rebase
Dit bovenstaande commando is het meest bruikbare commando in mijn git-leven, dat veel tijd heeft bespaard.
Voordat je je nieuwe commits naar de server pusht, probeer je dit commando en het zal automatisch de laatste serverwijzigingen synchroniseren (met een fetch + merge) en zal je commit bovenaan in git log plaatsen. U hoeft zich geen zorgen te maken over handmatig ophalen / samenvoegen.
Vind details op: http://gitolite.com/git-pull--rebase
|
Ik heb graag een visuele weergave van de situatie om deze dingen te begrijpen. Misschien willen andere ontwikkelaars het ook zien, dus hier is mijn toevoeging. Ik weet niet helemaal zeker of alles klopt, dus geef alsjeblieft commentaar als je fouten vindt.
LOKAAL SYSTEEM
. ==================================================== ===
=================. ================= =================== =============
REMOTE REPOSITORY. REMOTE REPOSITORY LOKALE REPOSITORY WERKKOPIE
(OORSPRONG). (CACHED)
bijvoorbeeld, . spiegel van de
een github-repo. . externe opslagplaats
Kan ook zijn .
meerdere repo's.
.
.
FETCH * ------------------> *
Uw lokale cache van de afstandsbediening wordt bijgewerkt met de oorsprong (of meerdere
externe bronnen, dat is de gedistribueerde aard van git)
.
TREKKEN *------------------------------------------------ --------> *
wijzigingen worden direct in uw lokale kopie samengevoegd. wanneer er conflicten optreden,
u wordt om beslissingen gevraagd.
.
COMMIT. * <--------------- *
Als je bijvoorbeeld uit subversion komt, zou je kunnen denken dat het een commit is
zal de oorsprong bijwerken. In git wordt een commit alleen gedaan naar je lokale repo.
.
PUSH * <--------------------------------------- *
Synchroniseert uw wijzigingen terug naar de oorsprong.
Enkele grote voordelen van het hebben van een opgehaalde spiegel van de afstandsbediening zijn:
Prestaties (scrol door alle commits en berichten zonder te proberen het door het netwerk te persen)
Feedback over de staat van je lokale repo (ik gebruik bijvoorbeeld Atlassian's SourceTree, die me een lamp geeft die aangeeft of ik voor of achter ben in vergelijking met de oorsprong. Deze informatie kan worden bijgewerkt met een GIT FETCH).
|
Ik heb hier ook mee geworsteld. In feite kwam ik hier met een google-zoekopdracht met precies dezelfde vraag. Toen ik al deze antwoorden las, schetste ik eindelijk een beeld in mijn hoofd en ik besloot dit te proberen door te kijken naar de staat van de 2 repositories en 1 sandbox en de acties die in de loop van de tijd werden uitgevoerd terwijl ik de versie ervan bekeek. Dus hier is wat ik bedacht. Corrigeer me als ik ergens een fout heb gemaakt.
De drie opslagplaatsen met een ophaalactie:
--------------------- ----------------------- ------ -----------------
- Repo op afstand - - Repo op afstand - - Repo op afstand -
- - - wordt geduwd - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Lokale Repo - - Lokale Repo - - Lokale Repo -
- trekken - - - - ophalen -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokale sandbox - - Lokale sandbox - - Lokale sandbox -
- Afrekenen - - nieuw werk gedaan - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
De drie repo's met een pull
--------------------- ----------------------- ------ -----------------
- Repo op afstand - - Repo op afstand - - Repo op afstand -
- - - wordt geduwd - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokale Repo - - Lokale Repo - - Lokale Repo -
- trekken - - - - trekken -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokale sandbox - - Lokale sandbox - - Lokale sandbox -
- Afrekenen - - nieuw werk gedaan - - samengevoegd met R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Dit hielp me te begrijpen waarom een ophaalactie behoorlijk belangrijk is.
|
Het verschil tussen GIT Fetch en GIT Pull kan worden verklaard met het volgende scenario:
(Houd er rekening mee dat afbeeldingen luider spreken dan woorden!, Ik heb een afbeelding weergegeven)
Laten we een voorbeeld nemen dat u met uw teamleden aan een project werkt. Er zal dus één hoofdvertakking van het project zijn en alle bijdragers moeten het naar hun eigen lokale repository splitsen en dan aan deze lokale vertakking werken om modules te wijzigen / toe te voegen en vervolgens terug te pushen naar de hoofdvertakking.
Zo,
De initiële staat van de twee filialen toen u het hoofdproject op uw lokale repository splitste, zal er als volgt uitzien- (A, B en C zijn modules die al zijn voltooid van het project)
Nu ben je aan de nieuwe module begonnen (stel D) en als je de D-module hebt voltooid, wil je deze naar de hoofdtak pushen, maar wat er ondertussen gebeurt is dat een van je teamgenoten nieuwe Module E, F en gemodificeerde C.
Dus wat er nu is gebeurd, is dat uw lokale repository achter de oorspronkelijke voortgang van het project ontbreekt en dat het pushen van uw wijzigingen naar de hoofdtak kan leiden tot conflicten en dat uw Module D defect kan raken.
Om dergelijke problemen te vermijden en parallel te werken met de oorspronkelijke voortgang van het project, zijn er twee manieren:
1. Git Fetch- Dit zal alle wijzigingen downloaden die zijn aangebracht in het origin / main branch-project die niet aanwezig zijn in je lokale branch. En zal wachten op het Git Merge-commando om de wijzigingen toe te passen die zijn opgehaald in je Repository of branch.
Dus nu kunt u de bestanden zorgvuldig volgen voordat u ze samenvoegt met uw repository. En u kunt D desgewenst ook wijzigen vanwege Modified C.
2. Git Pull- Dit zal je lokale branch updaten met de origin / main branch, d.w.z. wat het eigenlijk doet is een combinatie van Git Fetch en Git merge na elkaar.
Maar dit kan ervoor zorgen dat er conflicten optreden, dus het wordt aanbevolen om Git Pull te gebruiken met een schone kopie.
|
We zeggen simpelweg:
git pull == git fetch + git merge
Als je git pull uitvoert, hoef je de gegevens niet samen te voegen naar local. Als je git fetch uitvoert, betekent dit dat je git merge moet uitvoeren om de laatste code op je lokale machine te krijgen. Anders zou de lokale machinecode niet worden gewijzigd zonder samenvoegen.
Dus in de Git Gui, als je fetch doet, moet je de data samenvoegen. Fetch zelf zal de codewijzigingen bij uw lokale server niet aanbrengen. U kunt dat controleren wanneer u de code bijwerkt door
eenmaal halen en zien; de code zal het niet veranderen. Dan voeg je samen ... Je ziet de gewijzigde code.
|
git fetch haalt de code van de externe server naar je tracking-branches in je lokale repository. Als je remote de naam origin (de standaard) heeft, zullen deze branches binnen origin / vallen, bijvoorbeeld origin / master, origin / mybranch-123, etc. Dit zijn niet je huidige branches, het zijn lokale kopieën van die branches van de server .
git pull doet een git fetch maar voegt dan ook de code van de tracking branch in je huidigelokale versie van die branch. Als je nog niet klaar bent voor die wijzigingen, ga dan eerst git fetch.
|
git fetch zal remote branches ophalen zodat je git diff of git kunt mergen met de huidige branch. git pull zal fetch uitvoeren op de externe brach die wordt gevolgd door de huidige branch en vervolgens het resultaat samenvoegen. Je kunt git fetch gebruiken om te zien of er updates zijn voor de remote branch zonder ze met je lokale branch te moeten samenvoegen.
|
Git Fetch
U downloadt wijzigingen naar uw lokale branch van origin tot fetch. Fetch vraagt de remote repo om alle commits die anderen hebben gedaan maar die je niet op je lokale repo hebt staan. Fetch downloadt deze commits en voegt ze toe aan de lokale repository.
Git samenvoegen
U kunt wijzigingen die zijn gedownload via fetch toepassen met de opdracht samenvoegen. Samenvoegen neemt de commits die uit fetch zijn opgehaald en probeert ze toe te voegen aan je lokale branch. Het samenvoegen zal de vastleghistorie van je lokale wijzigingen bewaren, zodat wanneer je je branch met push deelt, Git zal weten hoe anderen je wijzigingen kunnen samenvoegen.
Git Pull
Ophalen en samenvoegen werken zo vaak samen dat er een commando is gemaakt dat de twee combineert, pull. Pull doet een fetch en vervolgens een merge om de gedownloade commits toe te voegen aan je lokale branch.
|
In eenvoudige bewoordingen, als je op het punt stond om in een vliegtuig te springen zonder enige internetverbinding ... voordat je vertrekt, kun je gewoon git fetch origin doen. Het haalt alle wijzigingen op uw computer, maar houdt het gescheiden van uw lokale ontwikkel- / werkruimte.
In het vliegtuig kunt u wijzigingen aanbrengen in uw lokale werkruimte en deze vervolgens samenvoegen met wat u heeft opgehaald en mogelijke samenvoegconflicten oplossen, allemaal zonder verbinding met internet. En tenzij iemand nieuwe wijzigingen had aangebracht in de remote repository, dan zou je, zodra je op de bestemming aankomt, git push origin doen en je koffie gaan halen.
Van deze geweldige Atlassian-tutorial:
Het git fetch commando downloadt commits, bestanden en refs van een
externe repository naar uw lokale repository.
Ophalen is wat u doet als u wilt zien wat alle anderen hebben
gewerkt aan. Het is vergelijkbaar met de SVN-update omdat het u laat zien
hoe de centrale geschiedenis is gevorderd, maar het dwingt je er niet toe
voeg de wijzigingen daadwerkelijk samen in uw repository. Git isoleert
opgehaalde inhoud als een van bestaande lokale inhoud, het heeft absoluut
geen effect op uw lokale ontwikkelingswerk. Opgehaalde inhoud moet expliciet worden uitgecheckt met behulp van het git checkout-commando. Dit maakt
een veilige manier ophalen om commits te beoordelen voordat ze worden geïntegreerd
uw lokale repository.
Bij het downloaden van inhoud van een externe repository, zijn git pull en git fetch commando's beschikbaar om de taak te volbrengen. U kunt overwegen
git haalt de 'veilige' versie van de twee commando's op. Het zal downloaden
de externe inhoud, maar niet de werkstatus van uw lokale repository bijwerken,
laat je huidige werk intact. git pull is de meer agressieve
alternatief downloadt het de externe inhoud voor de actieve lokale
branch en voer onmiddellijk git merge uit om een merge commit te maken
voor de nieuwe externe inhoud. Als u lopende wijzigingen heeft
dit veroorzaakt conflicten en start de oplossing van het samenvoegconflict
stromen.
Met git pull:
Je krijgt geen isolatie.
Het hoeft niet expliciet te worden uitgecheckt. Omdat het impliciet een git merge uitvoert.
De samenvoegstap heeft invloed op uw lokale ontwikkeling en kan conflicten veroorzaken
Het is eigenlijk NIET veilig. Het is agressief.
In tegenstelling tot git fetch waar het alleen invloed heeft op je .git / refs / remotes, heeft git pull zowel invloed op je .git / refs / remotes als .git / refs / heads /
Hmmm ... dus als ik de werkkopie niet bijwerk met git fetch, waar breng ik dan wijzigingen aan? Waar slaat Git fetch de nieuwe commits op?
Grote vraag. Het plaatst het ergens geïsoleerd van uw werkkopie. Maar nogmaals waar? Laten we het uitzoeken.
Doe in je projectdirectory (d.w.z. waar je je git-commando's doet):
ls. Dit toont de bestanden en mappen. Niets cools, ik weet het.
Doe nu ls -a. Dit toont puntbestanden, d.w.z. bestanden die beginnen met. U zult dan een directory kunnen zien met de naam: .git.
Doe cd .git. Dit zal uiteraard uw directory veranderen.
Nu komt het leuke gedeelte; doe ls. U ziet een lijst met mappen. We zoeken scheidsrechters. Doe cd-refs.
Het is interessant om te zien wat er in alle mappen staat, maar laten we ons concentreren op twee ervan. hoofden en afstandsbedieningen. Gebruik cd om ze ook te controleren.
Elke git fetch die je doet, zal items in de /.git/refs/remotes directory updaten. Het zal niets updaten in de /.git/refs/heads directory.
Elke git pull zal eerst de git fetch doen, items bijwerken in de /.git/refs/remotes directory, dan samenvoegen met je local en dan de head in de /.git/refs/heads directory veranderen.
Een heel goed gerelateerd antwoord is ook te vinden in Waar plaatst 'git fetch' zichzelf ?.
Zoek ook naar "Slash-notatie" in de post Git branch naamgeving. Het helpt je beter te begrijpen hoe Git dingen erin plaatstverschillende mappen.
Om het werkelijke verschil te zien
Gewoon doen:
git fetch oorsprong master
git checkout master
Als de externe master is bijgewerkt, krijgt u een bericht als dit:
Je branch staat achter 'origin / master' met 2 commits, en kan snel worden doorgespoeld.
(gebruik "git pull" om je lokale branch bij te werken)
Als je niet hebt opgehaald en gewoon git checkout master hebt gedaan, dan zou je lokale git niet weten dat er 2 commits zijn toegevoegd. En het zou gewoon zeggen:
Al op 'master'
Uw branch is up-to-date met 'origin / master'.
Maar dat is verouderd en onjuist. Het is omdat git je feedback zal geven uitsluitend op basis van wat het weet. Het is zich niet bewust van nieuwe commits die het nog niet heeft afgebroken ...
Is er een manier om de nieuwe wijzigingen die op afstand zijn aangebracht te zien terwijl ik lokaal aan de branch werk?
Sommige IDE's (bijv.Xcode) zijn super slim en gebruiken het resultaat van een git fetch en kunnen de coderegels annoteren die zijn gewijzigd in de remote branch van je huidige werkende branch. Als die regel is gewijzigd door zowel lokale wijzigingen als een vertakking op afstand, wordt die regel met rood geannoteerd. Dit is geen samenvoegconflict. Het is een mogelijk samenvoegconflict. Het is een heads-up die je kunt gebruiken om het toekomstige samenvoegconflict op te lossen voordat je git pull doet vanuit de remote branch.
Leuke tip:
Als je een afgelegen tak hebt opgehaald, b.v. deed:
git fetch oorsprong feature / 123
Dit zou dan naar uw afstandsbedieningenlijst gaan. Het is nog steeds niet beschikbaar in uw lokale directory. Het vereenvoudigt echter uw checkout naar die externe branch door DWIM (doe wat ik bedoel):
git checkout functie / 123
u hoeft niet langer te doen:
git checkout -b feature / 123 origin / feature / 123
Lees hier meer over
|
Het enige verschil tussen git pull en git fetch is dat:
git pull haalt uit een externe branch en voegt het samen.
git fetch haalt alleen op van de remote branch, maar het gaat niet samen
d.w.z. git pull = git fetch + git merge ...
|
Git staat toe dat chronologisch oudere commits worden toegepast na nieuwere commits.
Daarom wordt het overzetten van commits tussen repositories opgesplitst in twee stappen:
Nieuwe commits kopiëren van een remote branch naar een kopie van deze remote branch in de lokale repo.
(repo naar repo-bewerking) master @ remote >> remote / origin / master @ local
Integratie van nieuwe commits naar lokale vestiging
(inside-repo-bewerking) remote / origin / master @ local >> master @ local
Er zijn twee manieren om stap 2 uit te voeren. U kunt:
Fork de lokale branch na de laatste gemeenschappelijke voorouder en voeg nieuwe commits toe parallel aan commits die uniek zijn voor de lokale repository, afgerond door commit samen te voegen en de fork te sluiten.
Voeg nieuwe commits in na de laatste gemeenschappelijke voorouder en pas de commits opnieuw toe die uniek zijn voor de lokale repository.
In git-terminologie is stap 1 git fetch, stap 2 is git merge of git rebase
git pull is git fetch en git merge
|
Git verkrijgt de branch van de laatste versie van de remote naar de local met behulp van twee commando's:
git fetch: Git gaat de laatste versie van remote naar lokaal halen, maar het gaat niet automatisch samen.
git fetch oorsprong master
git log -p master..origin / master
git merge origin / master
De bovenstaande commando's betekenen dat de laatste versie van de hoofdbranch van origin van de remote naar de origin master branch wordt gedownload. En vergelijkt vervolgens de lokale master branch en origin master branch. Voeg ten slotte samen.
git pull: Git gaat de laatste versie van de remote halen en in de lokale mergen.
git pull oorsprong master
Het bovenstaande commando is het equivalent van git fetch en git merge. In de praktijk is git fetch misschien veiliger omdat we vóór het samenvoegen de wijzigingen kunnen zien en kunnen beslissen of we samenvoegen.
|
Wat is het verschil tussen git pull en git fetch?
Om dit te begrijpen, moet je eerst begrijpen dat je lokale git niet alleen je lokale repository onderhoudt, maar ook een lokale kopie van de remote repository bijhoudt.
git fetch brengt je lokale kopie van de remote repository up-to-date. Als je externe repository bijvoorbeeld GitHub is, wil je misschien alle wijzigingen die in de externe repository zijn gemaakt, ophalen naar je lokale kopie ervan, de externe repository. Hiermee kunt u bewerkingen uitvoeren zoals vergelijken of samenvoegen.
git pull aan de andere kant zal de veranderingen in de externe repository naar beneden halen waar je je eigen code bewaart. Typisch zal git pull eerst een git fetch uitvoeren om de lokale kopie van de remote repository up-to-date te brengen, en dan zal het de wijzigingen samenvoegen in je eigen code repository en mogelijk je werkkopie.
|
git pull == (git fetch + git merge)
git fetch verandert niet in lokale branches.
Als je al een lokale repository hebt met een remote set-up voor het gewenste project, kun je alle branches en tags voor de bestaande remote pakken met git fetch. ... Fetch brengt geen wijzigingen aan in lokale branches, dus je zult een remote branch moeten samenvoegen met een gepaarde lokale branch om nieuwe fetch-wijzigingen op te nemen. van github
|
Een eenvoudige grafische weergave voor beginners,
hier,
git pull
zal code ophalenvanuit de repository en rebase met je lokale ... in git pull is er de mogelijkheid dat nieuwe commits worden gemaakt.
maar in ,
git fetch
zal code uit de repository halen en we moeten het handmatig rebasen door git rebase te gebruiken
bijv .: ik ga ophalen van servermaster en rebasen in mijn lokale master.
1) git pull (rebase wordt automatisch gedaan):
git pull oorsprong master
hier origin is je remote repo master is je branch
2) git fetch (moet handmatig rebasen):
git fetch oorsprong master
het haalt serverwijzigingen van oorsprong op. en het zal in uw lokale taal zijn totdat u het zelf rebaseert. we moeten conflicten handmatig oplossen door codes te controleren.
git rebase oorsprong / master
dit zal de code rebasen naar lokaal. zorg ervoor dat u zich in de juiste branche bevindt.
|
Probeer duidelijk en eenvoudig te zijn.
Het git pull commando is eigenlijk een snelkoppeling voor git fetch gevolgd door het git merge of het git rebase commando, afhankelijk van je configuratie. Je kunt je Git-repository zo configureren dat git pull een fetch is gevolgd door een rebase.
|
Eigenlijk onderhoudt Git een kopie van uw eigen code en
de externe opslagplaats.
Het commando git fetch maakt je lokale kopie up-to-date door gegevens op te halen uit een externe repository. De reden dat we dit nodig hebben, is omdat iemand anders mogelijk enkele wijzigingen in de code heeft aangebracht en u uzelf op de hoogte wilt houden.
Het commando git pull brengt de veranderingen in de remote repository waar je je eigen code bewaart. Normaal gesproken doet git pull dit door eerst een ‘git fetch’ uit te voeren om de lokale kopie van de externe repository up-to-date te brengen, en daarna voegt het de wijzigingen samen in je eigen coderepository en mogelijk je werkkopie.
|
1
2
De volgende
Zeer actieve vraag. Verdien 10 reputatie om deze vraag te beantwoorden. De reputatievereiste helpt deze vraag te beschermen tegen spam en niet-beantwoording.
Niet het antwoord waar je naar zoekt? Blader door andere vragen met de tag git version-control git-pull git-fetch of stel je eigen vraag.